{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "instructional-length",
   "metadata": {},
   "source": [
    "# 量子核方法\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "desirable-compatibility",
   "metadata": {},
   "source": [
    "## 概览\n",
    "\n",
    "在量子机器学习中，参数化量子电路（parameterized quantum circuit）扮演着重要的角色。在很多场景中，为了类比经典机器学习领域中的神经网络方法，我们也经常会把参数化量子电路称为量子神经网络。但是实际上，在量子机器学习的相关应用中，人们发现参数化量子电路的数学原理更类似于经典机器学习中的核方法（kernel methods）[1]。这种通过将量子计算和经典核方法相结合的思路以及研究方法，就被称为量子核方法（quantum kernel methods）。这两种方法的结合对于量子计算如何更好的解决一系列机器学习问题提供了全新的视角，因此在近年来收到了极大的关注 [2-7]。在本教程中，我们将探究如何用量子核方法结合支持向量机来实现数据分类。\n",
    "\n",
    "### 理论背景\n",
    "\n",
    "在经典机器学习中，核方法一般指的是将低维的数据向量通过特征映射（feature map）映射到高维的特征空间（feature space）中，来识别低维数据中难以分辨的模式的方法。如图1的例子所示，通过将一维的线性不可分数据映射到二维，映射后的数据在二维空间中是线性可分的。\n",
    "\n",
    "![feature map](./figures/Qkernel-fig-featuremap.png \"图1：核方法中的特征映射\")\n",
    "<div style=\"text-align:center\">图1：核方法中的特征映射 </div>\n",
    "\n",
    "不过，在实际应用中，由于特征空间的维数可能会十分巨大，我们往往并不希望直接对映射后的特征向量进行分析。相反，通过核方法中的另一个核心概念-核函数（kernel function），我们可以隐式地引入特征映射在模式识别上的优势。核函数的定义为数据向量在特征空间里的内积，其具体形式为\n",
    "\n",
    "$$\n",
    "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "其中 $\\phi()$ 就代表着特征映射。需要注意的是，在核方法中我们并不需要显式地写出特征映射，而只需要定义核函数的形式即可。\n",
    "\n",
    "在经典机器学习中，核方法最具代表性的应用就是支持向量机（support vector machine, SVM）。简单的来说，支持向量机解决的是线性分类问题：以一个二分类的问题举例，我们的数据集为 $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$，通过一个超平面 $(\\mathbf{w}, b)$，支持向量机可以通过如下决策函数的正负来预测每个数据点 $\\mathbf{x}$ 的标签：\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "但是对于在原始数据空间中线性不可分的数据而言，这样的做法往往并不可行。所以如图1所示，通过引入我们上文中提到的特征映射，我们可以将原始数据空间中的数据向量映射到特征空间中来进行分类，从而得到更好的分类效果。此时，我们标记特征空间中的超平面为 $(\\mathbf{w}', b')$, 我们的决策函数就变成了：\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "更进一步的是，我们可以通过对偶化的方法，引入拉格朗日乘子 $\\alpha_i$ 来表示此时的分割超平面 $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ [8]。此时，我们可以在 $\\alpha_i \\geq 0$，$\\sum_i y_i \\alpha_i=0$ 的约束下，通过最大化\n",
    "\n",
    "$$\n",
    "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i)\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "来计算最优参数 $\\alpha_i^*$。不难发现，此时我们只需要计算数据向量在特征空间里的内积 $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$，正是我们上文中提到的核函数。换言之，在支持向量机中，我们不需要显式地知道特征映射的形式，而只需要计算原始数据在特征空间里的内积，就可以实现在特征空间中对数据进行分类。并且，对于任何新的数据向量 $\\mathbf{x}'$，我们只需要通过核函数 $K(,)$ 计算\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i  \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n",
    "{\\rm sign}(\\sum_i \\alpha^*_i  K(\\mathbf{x}_i, \\mathbf{x}') + b'),\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "就可以对数据的标签进行预测。\n",
    "\n",
    "借助这种思想，我们就可以很简单的理解量子核方法的内涵。首先，我们引入量子特征空间的概念，即我们认为我们通过一个编码电路 $U(\\mathbf{x}) $ 将经典数据向量 $\\mathbf{x} $ 编码到某个量子态 $| \\phi(\\mathbf{x}) \\rangle$ 上：\n",
    "\n",
    "$$\n",
    "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n",
    "\\tag{6}\n",
    "$$ \n",
    "\n",
    "关于编码电路的具体形式我们这里不做展开，感兴趣的读者可以阅读我们的[编码教程](./DataEncoding_CN.ipynb)来了解不同的量子编码电路形式。此时我们的量子特征映射就是从经典数据空间到量子态所处的希尔伯特空间的一种特殊特征映射。在这个基础上，我们将量子核函数（quantum kernel function）定义为经典数据向量在量子特征空间的内积，其具体形式就为\n",
    "\n",
    "$$\n",
    "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "上式可以进一步写为\n",
    "\n",
    "$$\n",
    "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 =  |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "不难发现，通过运行如图2中所示的量子电路，并在统计其测量结果为 $| 0^{\\otimes N} \\rangle $ 的概率，我们就可以估计式（8）中的量子核函数。这种方法也被称为量子核估计（quantum kernel estimation, QKE）方法。也就是说，如果我们通过量子核估计方法来计算式（4-5) 中的核函数的话，我们就可以利用支持向量机的方法在量子特征空间来完成数据分类。借助量子特征映射的量子性，人们希望这种量子核方法可以更好地分类具有复杂模式的数据。人们已经证明，通过精心设计量子特征映射，量子核方法就可以用来分辨任何经典方法都无法识别的数据模式 [3]。\n",
    "\n",
    "![QKE](./figures/Qkernel-fig-QKE.png \"图2：量子核估计电路\")\n",
    "<div style=\"text-align:center\">图2：量子核估计电路 </div>\n",
    "\n",
    "![illustration](./figures/Qkernel-fig-illustrationCN.png \"图3：经典核方法和量子核方法的对比示意图\")\n",
    "<div style=\"text-align:center\">图3：经典核方法和量子核方法的对比示意图 </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "willing-shopping",
   "metadata": {},
   "source": [
    "### 拓展：量子机器学习和核方法的联系\n",
    "\n",
    "在量子机器学习中，往往我们量子电路中的一部分需要将经典的数据编码到其对应的量子态上，其数学形式为：\n",
    "\n",
    "$$\n",
    "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n",
    "\\tag{9}\n",
    "$$\n",
    "\n",
    "其中 $U(x)$ 是一个取决于经典数据 $x$ 的参数化电路。正如我们上文中提到的，这种编码的过程可以被考虑成是一种从经典数据空间到量子特征空间的特殊特征映射。同时，考虑一个作用在编码量子态上的量子神经网络电路，其数学形式为：\n",
    "\n",
    "$$\n",
    "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n",
    "\\tag{10}\n",
    "$$\n",
    "\n",
    "其中 $U_{\\rm QNN}(\\theta)$ 为代表量子神经网络的参数化量子电路，$\\theta$ 为其中的参数。我们在电路的最后进行测量，该测量用 $\\mathcal{M}$ 表示。这时，我们测得的期望值为\n",
    "\n",
    "$$\n",
    "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n",
    "\\tag{11}\n",
    "$$\n",
    "\n",
    "我们不妨将测量写成算符的形式 $| \\sigma \\rangle \\langle \\sigma |$ ，那么式（11）就可以进一步被写为\n",
    "\n",
    "$$\n",
    "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta)  | \\phi(x) \\rangle = \n",
    "|\\langle \\sigma' (\\theta)  | \\phi(\\mathbf{x}) \\rangle|^2,\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "其中 $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$。这样的话，我们发现我们这种基于量子神经网络的测量结果也可以被认为是量子特征空间中两个量子特征向量的内积：$|\\langle \\sigma' (\\theta)  | \\phi(\\mathbf{x}) \\rangle|^2$。\n",
    "而该内积，正是我们前文中提到的量子核函数，只不过其中一个特征向量是由一个参数化的测量所描述的。这也就是我们在本教程的一开始提到，量子神经网络模型的数学形式实际上更接近于经典机器学习中的核方法的原因。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tutorial-vocabulary",
   "metadata": {},
   "source": [
    "## 示例：利用量子核方法来解决分类问题\n",
    "\n",
    "> 本教程需要使用 [`sklearn`](https://scikit-learn.org/stable/install.html) 中的相关函数来实现支持向量机的功能。需要的读者可以运行下面的代码块来安装相关模块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "informative-miami",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "!pip install scikit-learn\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "emerging-anxiety",
   "metadata": {},
   "source": [
    "下面，我们用一个简单的例子来展示如何在 Paddle Quantum 中模拟量子核估计电路，并将其应用在一个实际的分类任务上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "acting-nursery",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import paddle\n",
    "from numpy import pi as PI\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from paddle import matmul, transpose\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.gate import IQPEncoding\n",
    "import paddle_quantum\n",
    "\n",
    "import sklearn\n",
    "from sklearn import svm\n",
    "from sklearn.datasets import fetch_openml, make_moons, make_circles\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from IPython.display import clear_output\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fluid-rating",
   "metadata": {},
   "source": [
    "首先，我们生成两类线性不可分的二维圆形数据点作为我们的训练集和测试集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "turkish-energy",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "先来看一下我们的训练集和测试集:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 生成训练集和测试集\n",
    "X_train, y_train = make_circles(10, noise=0.05, factor=0.2, random_state=0)\n",
    "X_test, y_test = make_circles(10, noise=0.05, factor=0.2, random_state=1024)\n",
    "\n",
    "# 将生成的数据集进行可视化\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], \n",
    "              marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n",
    "ax[0].set_title('Train')\n",
    "ax[1].set_title('Test')\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n",
    "\n",
    "print(\"先来看一下我们的训练集和测试集:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "federal-representation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 初始化进度条\n",
    "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n",
    "pbar = tqdm(total=100, bar_format=bar_format_string)\n",
    "pbar.close()\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "educated-permission",
   "metadata": {},
   "source": [
    "下面，我们来用 PaddleQuantum 来搭建量子核函数的计算电路："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "every-competition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "检查是否满足 K(x, x) = 1？ True\n"
     ]
    }
   ],
   "source": [
    "# 初始化一个用来更新进度条的全局变量\n",
    "N = 1\n",
    "\n",
    "# 通过 paddle quantum 模拟的 QKE 电路\n",
    "def q_kernel_estimator(x1, x2):\n",
    "    \n",
    "    # 将数据类型转换为 tensor\n",
    "    x1 = paddle.to_tensor(x1)\n",
    "    x2 = paddle.to_tensor(x2)\n",
    "    \n",
    "    # 创建电路\n",
    "    cir = paddle_quantum.ansatz.Sequential()\n",
    "    \n",
    "    # 添加对应第一个数据的编码电路\n",
    "    cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x1))\n",
    "    init_state = paddle_quantum.state.zero_state(2)\n",
    "    state = cir[0](state=init_state)\n",
    "    \n",
    "    # 添加对应第二个数据的编码电路的逆电路\n",
    "    cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x2))\n",
    "    fin_state = cir[1](state=state,invert=True).data\n",
    "    \n",
    "    # 更新进度条\n",
    "    global pbar\n",
    "    global N\n",
    "    pbar.update(100/N)\n",
    "\n",
    "    # 返回测量结果为 0...0 的概率\n",
    "    return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n",
    "\n",
    "# 按照规范定义需要传入的 Kernel 矩阵函数\n",
    "# 按照规范，输入应为两个数据列表\n",
    "def q_kernel_matrix(X1, X2):\n",
    "    return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n",
    "\n",
    "# 可视化决策函数（预测值），以及决策边界\n",
    "def visualize_decision_bound(clf):\n",
    "    \n",
    "    # 创建一个 10x10 的网格\n",
    "    x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n",
    "    y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n",
    "    XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n",
    "                         np.linspace(-1.2, 1.2, 10))\n",
    "    \n",
    "    # 计算分类器该网格上的预测值\n",
    "    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n",
    "    Z_qke = Z.reshape(XX.shape)\n",
    "    \n",
    "    # 可视化决策函数，以及决策边界\n",
    "    clear_output()\n",
    "    plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n",
    "                 cmap=matplotlib.cm.coolwarm, alpha=1)\n",
    "    plt.scatter(X_train[:,0], X_train[:,1], \n",
    "                c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n",
    "               edgecolor='black')\n",
    "    plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "                c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n",
    "               edgecolor='black')\n",
    "    plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n",
    "                levels=[-.2, 0, .2])\n",
    "\n",
    "# 作为检查量子核函数是否运行正常，我们可以检查 K(x, x) 是否等于 1\n",
    "# 提示：根据内积的定义 <x, x> = 1\n",
    "print('检查是否满足 K(x, x) = 1？',\n",
    "      bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "requested-cameroon",
   "metadata": {},
   "source": [
    "接下来，让我们尝试用量子核支持向量机（QKE-SVM）来进行数据分类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "caring-daily",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "让我们看一下量子核支持向量机的分类效果如何:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='训练 QKE-SVM 并分类中', \n",
    "            bar_format=bar_format_string)\n",
    "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n",
    "\n",
    "# 创建一个具有量子核函数的支持向量机\n",
    "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n",
    "\n",
    "# 根据训练数据计算支持向量机的决策平面\n",
    "svm_qke.fit(X_train, y_train)\n",
    "\n",
    "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n",
    "predict_svm_qke_train = svm_qke.predict(X_train)\n",
    "predict_svm_qke_test = svm_qke.predict(X_test)\n",
    "\n",
    "# 计算准确率\n",
    "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n",
    "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n",
    "\n",
    "# 可视化分类预测结果\n",
    "pbar.close()\n",
    "clear_output()\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n",
    "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n",
    "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n",
    "print(\"让我们看一下量子核支持向量机的分类效果如何:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "distinguished-dependence",
   "metadata": {},
   "source": [
    "更进一步的，我们还可以检查此时的决策函数平面以及决策边界："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "universal-genome",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "计算 QKE-SVM 的决策函数中: 100%|█████████████████████████████████████████████████▉|[00:09<00:00, 10.09it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='计算 QKE-SVM 的决策函数中', \n",
    "            bar_format=bar_format_string)\n",
    "N = 10 ** 2 * len(X_train)\n",
    "    \n",
    "# 可视化决策函数平面\n",
    "visualize_decision_bound(svm_qke)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "transsexual-swift",
   "metadata": {},
   "source": [
    "可以看到，量子核函数可以很好的学习到数据中的非线性特征。实际上，量子核方法的表现取决于量子特征映射的设计。并且，对于如何设计更好的量子核函数的探究才刚刚开始：一方面，我们可以尝试不同的数据编码方式；另一方面，我们可以尝试通过训练量子特征映射的方式提升分类效果 [5-6]；最后，我们还可以尝试一些不同的量子核函数形式 [7]。\n",
    "\n",
    "下面，作为拓展，我们也将展示一种特殊的量子核函数:投影量子核函数（projected quantum kernel）。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "scenic-circuit",
   "metadata": {},
   "source": [
    "### 拓展：投影量子核函数\n",
    "\n",
    "上文中已经提到，量子核方法通过将经典信息映射到潜在的高维量子特征空间来分辨在经典空间不可分的信息。但是，当我们的量子特征空间-希尔伯特空间的维度太大的时候，所有映射到希尔伯特空间的量子态都会接近于相互垂直的状态，此时的核矩阵将会近似的变成一个单位矩阵 $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$。为了避免这种维度问题的出现，我们需要首先从高维希尔伯特空间提取出足够的低维信息。投影量子核方法就是遵循了这个思路，即将量子态投影到新的经典空间，再在这个新的经典空间使用核方法。我们可以认为每一个投影是从不同的角度去观测希尔伯特空间的量子态，从足够多的角度测量这个量子态可以使我们获得足够重构这个态的经典信息。但在实际应用中，通常只需要从几个角度测量就能得到比较好的结果 [5]。 由于这个经典空间保留了部分希尔伯特空间中的重要特征，所以信息在这个经典空间的可分性优于原来的经典空间。\n",
    "\n",
    "投影量子核函数有很多不同的形式，这里我们举一个最为代表性的作为例子：\n",
    "\n",
    "$$\n",
    "K^{PQ}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "其中 $k$ 是用来标记多量子比特约化密度矩阵的下标，$\\mathcal{M}$ 是一个作用在多量子比特约化密度矩阵上的测量的集合。在这里，我们取 $k = 0, 1$，即两个单量子比特的约化密度矩阵，$M = \\{X, Y, Z \\}$，即一组 Pauli 测量。\n",
    "\n",
    "我们先尝试用 Paddle Quantum 来实现对应的投影量子核电路："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "artificial-hierarchy",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 因为这次我们的特征映射的特征空间也是经典的，我们不妨先把该映射写出来\n",
    "def projected_q_feature_map(x):\n",
    "    # 将经典数据转换为 Tensor\n",
    "    x = paddle.to_tensor(x)\n",
    "    \n",
    "    # 更新进度条\n",
    "    global N\n",
    "    pbar.update(100/N)\n",
    "    \n",
    "    init_state = paddle_quantum.state.zero_state(2)\n",
    "\n",
    "    # 进行投影测量，返回其期望值作为经典特征向量\n",
    "    res = []\n",
    "    for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']:\n",
    "        cir = paddle_quantum.ansatz.Sequential()\n",
    "        cir.append(IQPEncoding(qubits_idx=[[0, 1]], feature=x))\n",
    "        state = cir[0](init_state)\n",
    "        hamiltonian = paddle_quantum.Hamiltonian([[1.0, op_pauli]])\n",
    "        cir.append(paddle_quantum.loss.ExpecVal(hamiltonian))\n",
    "        res.append(cir[1](state).numpy()[0])\n",
    "    return res\n",
    "\n",
    "# 按照上文公式计算投影量子核函数\n",
    "def p_quantum_kernel_estimator(x1, x2):\n",
    "    \n",
    "    # 分别得到特征向量，并计算核函数\n",
    "    p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n",
    "    p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n",
    "    \n",
    "    return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n",
    "\n",
    "# 类似地，按照规范定义传入支持向量机的核函数\n",
    "def p_quantum_kernel_matrix(X1, X2):\n",
    "    return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baking-bridges",
   "metadata": {},
   "source": [
    "接下来，让我们看一下如何用投影量子核支持向量机（PQK-SVM）来进行数据分类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "chronic-terrorist",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "让我们看一下投影量子核支持向量机的分类效果如何:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='训练 PQK-SVM 并分类中', \n",
    "            bar_format=bar_format_string)\n",
    "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n",
    "\n",
    "# 创建一个具有投影量子核函数的支持向量机\n",
    "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n",
    "\n",
    "# 根据训练数据计算支持向量机的决策平面\n",
    "svm_pqk.fit(X_train, y_train)\n",
    "\n",
    "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n",
    "predict_svm_pqk_train = svm_pqk.predict(X_train)\n",
    "predict_svm_pqk_test = svm_pqk.predict(X_test)\n",
    "\n",
    "# 计算准确率\n",
    "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n",
    "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n",
    "\n",
    "# 可视化分类结果\n",
    "pbar.close()\n",
    "clear_output()\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n",
    "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n",
    "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n",
    "print(\"让我们看一下投影量子核支持向量机的分类效果如何:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "irish-embassy",
   "metadata": {},
   "source": [
    "同样的，我们检查一下此时的决策函数平面以及决策边界："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "chief-beach",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "计算 PQK-SVM 决策函数中: 100%|███████████████████████████████████████████████████▉|[01:28<00:00,  1.13it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='计算 PQK-SVM 决策函数中', \n",
    "            bar_format=bar_format_string)\n",
    "N = 2 * 10 ** 2 * len(X_train)\n",
    "    \n",
    "# 可视化决策函数平面\n",
    "visualize_decision_bound(svm_pqk)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "continuous-chance",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "在量子机器学习的研究中，研究者们希望借助量子力学的特点设计出可以超越经典机器学习方法的模型。随着该领域的研究越发深入，人们发现量子机器学习和传统机器学习可以通过核方法建立起深入的联系。相比“传统”的量子神经网络，量子核方法把研究的重点放在了从经典数据空间到量子希尔伯特空间的特征映射，而不是变分量子电路。这为量子机器学习带来了新的研究思路，并为设计出实用的量子算法带来了新的可能性。因此，我们鼓励读者一起来思考如何设计出更好的量子核函数，并将其应用在更多样的数据集上。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intimate-bible",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 参考资料\n",
    "\n",
    "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n",
    "\n",
    "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n",
    "\n",
    "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n",
    "\n",
    "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n",
    "\n",
    "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n",
    "\n",
    "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n",
    "\n",
    "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n",
    "\n",
    "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
